home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / plnk081.zip / pilot-link.0.8.1 / libsock / dlp.c < prev    next >
C/C++ Source or Header  |  1997-08-03  |  56KB  |  2,328 lines
  1. /* dlp.c:  Pilot DLP protocol
  2.  *
  3.  * Copyright (c) 1996, 1997, Kenneth Albanowski
  4.  *
  5.  * This is free software, licensed under the GNU Public License V2.
  6.  * See the file COPYING for details.
  7.  */
  8.  
  9. /*@+matchanyintegral@*/
  10. /*@-predboolint@*/
  11. /*@-boolops@*/ 
  12.  
  13. #include <stdio.h>
  14. #include "pi-source.h"
  15. #include "pi-socket.h"
  16. #include "pi-dlp.h"
  17. #include "pi-syspkt.h"
  18.  
  19. #define get_date(ptr) (dlp_ptohdate((ptr)))                        
  20.  
  21. #define set_date(ptr,val) (dlp_htopdate((val),(ptr)))
  22.  
  23. #define DLP_BUF_SIZE 0xffff
  24. static /*@checked@*/ unsigned char dlp_buf[DLP_BUF_SIZE];
  25. static /*@checked@*/ unsigned char exec_buf[DLP_BUF_SIZE];
  26.  
  27. char * dlp_errorlist[] = { 
  28.   "No error",
  29.   "General System error",
  30.   "Illegal Function",
  31.   "Out of memory",
  32.   "Invalid parameter",
  33.   "Not found",
  34.   "None Open",
  35.   "Already Open",
  36.   "Too many Open",
  37.   "Already Exists",
  38.   "Cannot Open",
  39.   "Record deleted",
  40.   "Record busy",
  41.   "Operation not supported",
  42.   "-Unused-",
  43.   "Read only",
  44.   "Not enough space",
  45.   "Limit exceeded",
  46.   "Sync cancelled",
  47.   "Bad arg wrapper",
  48.   "Argument missing",
  49.   "Bad argument size"
  50. };
  51.  
  52. char * dlp_strerror(int error) {
  53.   if (error<0)
  54.     error = -error;
  55.   if ((unsigned int)error>sizeof(dlp_errorlist))
  56.     return "Unknown error";
  57.   else
  58.     return dlp_errorlist[error];
  59. }
  60.  
  61. int dlp_trace = 0;
  62.  
  63. #ifndef NO_DLP_TRACE
  64. #define DLP_TRACE
  65.  
  66. #define Trace(name) \
  67.   if (dlp_trace)    \
  68.     fprintf(stderr, "DLP %d: %s\n", sd, #name);
  69. #define Expect(count)    \
  70.   if (result < count) {  \
  71.     if (result < 0) {    \
  72.       if (dlp_trace)     \
  73.         fprintf(stderr, "Result: Error: %s (%d)\n", dlp_errorlist[-result], result); \
  74.     } else {             \
  75.       if (dlp_trace)     \
  76.         fprintf(stderr, "Result: Read %d bytes, expected at least %d\n", result, count); \
  77.       result = -128;     \
  78.     }                    \
  79.     return result;       \
  80.   } else                 \
  81.     if (dlp_trace)       \
  82.       fprintf(stderr, "Result: No error, %d bytes\n", result);
  83.   
  84. #else
  85.  
  86. #define Trace(name)
  87. #define Expect(count)   \
  88.   if (result < count) { \
  89.     if (result >= 0)    \
  90.       result = -128;    \
  91.     return result;      \
  92.   }
  93.   
  94. #endif
  95.  
  96.  
  97. #if 0
  98. /* Eventual code to dynamically allocate buffer */
  99. void * dlp_buffer(int sd, int cmd, int arg, int arglen, struct pi_socket * ps)
  100. {
  101.   unsigned char * buf;
  102.   *ps = pi_find_socket(sd);
  103.   if (*ps)
  104.     return 0;
  105.   
  106.   len = 50 + msglen;
  107.   if (ps->dlpbuflen < len) {
  108.     ps->dlpbuflen = len+1024;
  109.     if (ps->dlpbuf) 
  110.       ps->dlpbuf = realloc(ps->dlpbuf, ps->dlpbuflen);
  111.     else
  112.       ps->dlpbuf = malloc(ps->dlpbuflen);
  113.   }
  114.   
  115.   buf = ps->dlpbuf;
  116.   
  117.   buf[0] = (unsigned char)cmd;
  118.   buf[1] = etc.
  119.   
  120. }
  121. #endif
  122.  
  123. int dlp_exec(int sd, int cmd, int arg, 
  124.              const unsigned char /*@null@*/ *msg, int msglen, 
  125.              unsigned char /*@out@*/ /*@null@*/ *result, int maxlen)
  126.  /*@modifies *result, exec_buf;@*/
  127.  /*@-predboolint -boolops@*/
  128. {
  129.   int i;
  130.   int err;
  131.   
  132.   exec_buf[0] = (unsigned char)cmd;
  133.   if (msg && arg && msglen) {
  134.     memcpy(&exec_buf[6], msg, msglen);
  135.     exec_buf[1] = (unsigned char)1;
  136.     exec_buf[2] = (unsigned char)(arg | 0x80);
  137.     exec_buf[3] = (unsigned char)0;
  138.     set_short(exec_buf+4, msglen);
  139.     i = msglen+6;
  140.   } else {
  141.     exec_buf[1] = (unsigned char)0;
  142.     i = 2;
  143.   }
  144.  
  145.   if (pi_write(sd, &exec_buf[0], i)<i) {
  146.     errno = -EIO;
  147.     return -1;
  148.   }
  149.  
  150.   i = pi_read(sd, &exec_buf[0], DLP_BUF_SIZE);
  151.  
  152.   err = get_short(exec_buf+2);
  153.   
  154.   if (err != 0) {
  155.     errno = -EIO;
  156.     return -err;
  157.   }
  158.  
  159.   if (exec_buf[0] != (unsigned char)(cmd | 0x80)) { /* received wrong response */
  160.     errno = -ENOMSG;
  161.     return -1;
  162.   }
  163.   
  164.   if ((exec_buf[1] == (unsigned char)0) || (result==0)) /* no return blocks or buffers */
  165.     return 0; 
  166.     
  167.   /* assume only one return block */
  168.   if ((exec_buf[4] & 0xC0) == 0xC0) { /* Long arg */
  169.       i = get_long(exec_buf+6);
  170.       
  171.       if (i>maxlen)
  172.         i = maxlen;
  173.         
  174.       memcpy(result, &exec_buf[10], i);
  175.   } else if (exec_buf[4] & 0x80) { /* Short arg */
  176.       i = get_short(exec_buf+6);
  177.       
  178.       if (i>maxlen)
  179.         i = maxlen;
  180.         
  181.       memcpy(result, &exec_buf[8], i);
  182.   } else { /* Tiny arg */
  183.       i = (int)exec_buf[5];
  184.  
  185.       if (i>maxlen)
  186.         i = maxlen;
  187.         
  188.       memcpy(result, &exec_buf[6], i);
  189.   }
  190.  
  191.   return i;
  192.   
  193. }
  194.  
  195. /* These conversion functions are strictly for use within the DLP layer.
  196.    This particular date/time format does not occur anywhere else within the
  197.    Pilot or its communications. */
  198.    
  199. /* Notice: These conversion functions apply a possibly incorrect timezone
  200.    correction. They use the local time on the UNIX box, and transmit this
  201.    directly to the Pilot. This assumes that the Pilot has the same local
  202.    time. If the Pilot is communicating from a different timezone, this is
  203.    not necessarily correct.
  204.    
  205.    It would be possible to compare the current time on the Pilot with the
  206.    current time on the UNIX box, and use that as the timezone offset, but
  207.    this would break if the Pilot had the wrong time, or one or the either
  208.    didn't have the proper local (wall) time.
  209.    
  210.    In any case, since the (possibly incorrect) timezone correction is
  211.    applied both way, there is no immediate problem.
  212.                                                                    -- KJA
  213.    */
  214.    
  215. static time_t dlp_ptohdate(unsigned const char * data)
  216. {
  217.         struct tm t;
  218.         
  219.         t.tm_sec   = (int)data[6];
  220.         t.tm_min   = (int)data[5];
  221.         t.tm_hour  = (int)data[4];
  222.         t.tm_mday  = (int)data[3];
  223.         t.tm_mon   = (int)data[2]-1;
  224.         t.tm_year  = ((data[0]<<8) | data[1])-1900;
  225.         t.tm_wday  = 0;
  226.         t.tm_yday  = 0;
  227.         t.tm_isdst = -1;
  228.         
  229.         return mktime(&t);
  230. }
  231.  
  232. static void dlp_htopdate(time_t time, unsigned char * data) /*@+ptrnegate@*/
  233. {
  234.         struct tm * t = localtime(&time);
  235.         int y;
  236.  
  237.         if (!t)
  238.           abort();
  239.         
  240.         y = t->tm_year+1900;
  241.         
  242.         data[7] = (unsigned char)0; /* packing spacer */
  243.         data[6] = (unsigned char)t->tm_sec;
  244.         data[5] = (unsigned char)t->tm_min;
  245.         data[4] = (unsigned char)t->tm_hour;
  246.         data[3] = (unsigned char)t->tm_mday;
  247.         data[2] = (unsigned char)(t->tm_mon+1);
  248.         data[0] = (unsigned char)((y >> 8) & 0xff);
  249.         data[1] = (unsigned char)((y >> 0) & 0xff);
  250.         
  251.         return;
  252. }
  253.  
  254. int dlp_GetSysDateTime(int sd, time_t * t)
  255. {
  256.   unsigned char buf[8];
  257.   int result;
  258.   
  259.   Trace(GetSysDateTime);
  260.   
  261.   result = dlp_exec(sd, 0x13, 0x20, 0, 0, buf, 8);
  262.   
  263.   Expect(8);
  264.   
  265.   *t = dlp_ptohdate(buf);
  266.  
  267. #ifdef DLP_TRACE
  268.   if (dlp_trace) {
  269.     fprintf(stderr, "   Read: Time: %s", ctime(t));
  270.   }
  271. #endif
  272.   
  273.   return result;
  274. }
  275.  
  276. int dlp_SetSysDateTime(int sd, time_t time)
  277. {
  278.   unsigned char buf[8];
  279.   int result;
  280.   dlp_htopdate(time, buf);
  281.  
  282.   Trace(ReadSysInfo);
  283.  
  284. #ifdef DLP_TRACE
  285.   if (dlp_trace) {
  286.     fprintf(stderr, "  Wrote: Time: %s", ctime(&time));
  287.   }
  288. #endif
  289.   
  290.   result = dlp_exec(sd, 0x14, 0x20, buf, 8, 0, 0);
  291.   
  292.   Expect(0);
  293.   
  294.   return result;
  295. }
  296.  
  297. /* begin struct SI
  298.  *  Byte    number        byte(0)
  299.  *  Byte    more        byte(1)
  300.  *  Byte    unused        byte(2)
  301.  *  Byte    count        byte(3)
  302.  *  Byte    totalSize        byte(4)
  303.  *  Byte    cardNo        byte(5)
  304.  *  Word    cardVersion        short(6)
  305.  *  DlpDateTimeType crDate    date(8)
  306.  *  DWord   romSize        long(16)
  307.  *  DWord   ramSize        long(20)
  308.  *  DWord   freeRam        long(24)
  309.  *  Byte    cardNameSize    byte(28)
  310.  *  Byte    cardManufSize    byte(29)
  311.  *  Char[0] cardNameAndManuf    byte(30)
  312.  * struct read access */
  313. #define SI_number(ptr)        get_byte((ptr)+0)
  314. #define SI_more(ptr)        get_byte((ptr)+1)
  315. #define SI_unused(ptr)        get_byte((ptr)+2)
  316. #define SI_count(ptr)        get_byte((ptr)+3)
  317. #define SI_totalSize(ptr)        get_byte((ptr)+4)
  318. #define SI_cardNo(ptr)        get_byte((ptr)+5)
  319. #define SI_cardVersion(ptr)        get_short((ptr)+6)
  320. #define SI_crDate(ptr)        get_date((ptr)+8)
  321. #define SI_romSize(ptr)        get_long((ptr)+16)
  322. #define SI_ramSize(ptr)        get_long((ptr)+20)
  323. #define SI_freeRam(ptr)        get_long((ptr)+24)
  324. #define SI_cardNameSize(ptr)        get_byte((ptr)+28)
  325. #define SI_cardManufSize(ptr)        get_byte((ptr)+29)
  326. #define SI_cardNameAndManuf(ptr,idx)    get_byte((ptr)+30+1*(idx))
  327. #define ptr_SI_cardNameAndManuf(ptr,idx)    ((ptr)+30+1*(idx))
  328. #define sizeof_SI        (30)
  329.  /* end struct SI */
  330.  
  331. /* begin struct SIRequest
  332.  *  Byte    cardNo        byte(0)
  333.  *  Byte    unused        byte(1)
  334.  * struct write access */
  335. #define SIRequest_cardNo(ptr,val)        set_byte((ptr)+0,(val))
  336. #define SIRequest_unused(ptr,val)        set_byte((ptr)+1,(val))
  337. #define sizeof_SIRequest        (2)
  338.  /* end struct SIRequest */
  339.  
  340. int dlp_ReadStorageInfo(int sd, int cardno, struct CardInfo * c)
  341. {
  342.   int result;
  343.   int len1,len2;
  344.   
  345.   SIRequest_cardNo(dlp_buf, cardno);
  346.   SIRequest_unused(dlp_buf, 0);
  347.   
  348.   Trace(ReadStorageInfo);
  349.   
  350. #ifdef DLP_TRACE
  351.   if (dlp_trace) {
  352.     fprintf(stderr, " Wrote: Cardno: %d\n", cardno);
  353.   }
  354. #endif  
  355.   
  356.   result = dlp_exec(sd, 0x15, 0x20, dlp_buf, 2, dlp_buf, 256+26);
  357.   
  358.   c->more = 0;
  359.   
  360.   Expect(sizeof_SI);
  361.   
  362.   c->more = SI_more(dlp_buf) || (SI_count(dlp_buf) > 1);
  363.   
  364.   c->card =    SI_cardNo(dlp_buf);
  365.   c->version =    SI_cardVersion(dlp_buf);
  366.   c->creation = SI_crDate(dlp_buf);
  367.   c->romSize =    SI_romSize(dlp_buf);
  368.   c->ramSize =    SI_ramSize(dlp_buf);
  369.   c->ramFree =    SI_freeRam(dlp_buf);
  370.   
  371.   len1 = SI_cardNameSize(dlp_buf);
  372.   memcpy(c->name, ptr_SI_cardNameAndManuf(dlp_buf,0), len1);
  373.   c->name[len1] = '\0';
  374.   
  375.   len2 = SI_cardManufSize(dlp_buf);
  376.   memcpy(c->manufacturer, ptr_SI_cardNameAndManuf(dlp_buf, len1), len2);
  377.   c->manufacturer[len2] = '\0';
  378.   
  379. #ifdef DLP_TRACE
  380.   if (dlp_trace) {  
  381.     fprintf(stderr, "  Read: Cardno: %d, Card Version: %d, Creation time: %s",
  382.       c->card, c->version, ctime(&c->creation));
  383.     fprintf(stderr, "        Total ROM: %lu, Total RAM: %lu, Free RAM: %lu\n",
  384.       c->romSize, c->ramSize, c->ramFree);
  385.     fprintf(stderr, "        Card name: '%s'\n", c->name);
  386.     fprintf(stderr, "        Manufacturer name: '%s'\n", c->manufacturer);
  387.     fprintf(stderr, "        More: %s\n", c->more ? "Yes" : "No");
  388.   }
  389. #endif
  390.   
  391.   return result;
  392. }
  393.  
  394.  
  395. int dlp_ReadSysInfo(int sd, struct SysInfo * s)
  396. {
  397.   int result;
  398.   
  399.   Trace(ReadSysInfo);
  400.   
  401.   result = dlp_exec(sd, 0x12, 0x20, NULL, 0, dlp_buf, 256);
  402.   
  403.   Expect(10);
  404.   
  405.   s->romVersion = get_long(dlp_buf);
  406.   s->locale = get_long(dlp_buf+4);
  407.   /* dlp_buf+8 is a filler byte */
  408.   s->nameLength = get_byte(dlp_buf+9);
  409.   memcpy(s->name, dlp_buf+10, s->nameLength);
  410.   s->name[s->nameLength] = '\0';
  411.  
  412. #ifdef DLP_TRACE
  413.   if (dlp_trace) {    
  414.     fprintf(stderr, "  Read: ROM Version: 0x%8.8lX, Localization ID: 0x%8.8lX\n",
  415.       (unsigned long)s->romVersion, (unsigned long)s->locale);
  416.     fprintf(stderr, "        Name '%s'\n", s->name);
  417.   }
  418. #endif
  419.   
  420.   return result;
  421. }
  422.  
  423. int dlp_ReadDBList(int sd, int cardno, int flags, int start, struct DBInfo * info)
  424. {
  425.   int result;
  426.  
  427.   dlp_buf[0] = (unsigned char)flags;
  428.   dlp_buf[1] = (unsigned char)cardno;
  429.   set_short(dlp_buf+2, start);
  430.  
  431.   Trace(ReadDBList);
  432.  
  433. #ifdef DLP_TRACE  
  434.   if (dlp_trace) {  
  435.     fprintf(stderr, " Wrote: Cardno: %d, Start: %d, Flags:", cardno, start);
  436.     if (flags & dlpDBListROM)
  437.       fprintf(stderr, " ROM");
  438.     if (flags & dlpDBListRAM)
  439.       fprintf(stderr, " RAM");
  440.     if (!flags)
  441.       fprintf(stderr, " None");
  442.     fprintf(stderr, " (0x%2.2X)\n", flags);
  443.   }
  444. #endif
  445.   
  446.   result = dlp_exec(sd, 0x16, 0x20, dlp_buf, 4, dlp_buf, 48+32);
  447.   
  448.   info->more = 0;
  449.   
  450.   Expect(48);
  451.   
  452.   info->more = get_byte(dlp_buf+2);
  453.   if (pi_version(sd) > 0x0100) /* PalmOS 2.0 has additional flag */
  454.     info->miscFlags = get_byte(dlp_buf+5);
  455.   else
  456.     info->miscFlags = 0;
  457.   info->flags = get_short(dlp_buf+6);
  458.   info->type = get_long(dlp_buf+8);
  459.   info->creator = get_long(dlp_buf+12);
  460.   info->version = get_short(dlp_buf+16);
  461.   info->modnum = get_long(dlp_buf+18);
  462.   info->createDate = get_date(dlp_buf+22);
  463.   info->modifyDate = get_date(dlp_buf+30);
  464.   info->backupDate = get_date(dlp_buf+38);
  465.   info->index = get_short(dlp_buf+46);
  466.   strncpy(info->name, (char*)dlp_buf+48, 32);
  467.   info->name[32] = '\0';
  468.  
  469. #ifdef DLP_TRACE
  470.   if (dlp_trace) {  
  471.     fprintf(stderr, "  Read: Name: '%s', Version: %d, More: %s\n",
  472.       info->name, info->version, info->more ? "Yes" : "No");
  473.     fprintf(stderr, "        Creator: '%s'", printlong(info->creator));
  474.     fprintf(stderr, ", Type: '%s', Flags:", printlong(info->type));
  475.     if (info->flags & dlpDBFlagResource)
  476.       fprintf(stderr, " Resource");
  477.     if (info->flags & dlpDBFlagReadOnly)
  478.       fprintf(stderr, " ReadOnly");
  479.     if (info->flags & dlpDBFlagAppInfoDirty)
  480.       fprintf(stderr, " AppInfoDirty");
  481.     if (info->flags & dlpDBFlagBackup)
  482.       fprintf(stderr, " Backup");
  483.     if (info->flags & dlpDBFlagReset)
  484.       fprintf(stderr, " Reset");
  485.     if (info->flags & dlpDBFlagNewer)
  486.       fprintf(stderr, " Newer");
  487.     if (info->flags & dlpDBFlagOpen)
  488.       fprintf(stderr, " Open");
  489.     if (!info->flags)
  490.       fprintf(stderr, " None");
  491.     fprintf(stderr, " (0x%2.2X)\n", info->flags);
  492.     fprintf(stderr, "        Modnum: %ld, Index: %d, Creation date: %s",
  493.       info->modnum, info->index, ctime(&info->createDate));
  494.     fprintf(stderr, "        Modification date: %s", ctime(&info->modifyDate));
  495.     fprintf(stderr, "        Backup date: %s", ctime(&info->backupDate));
  496.   }
  497. #endif
  498.     
  499.   return result;
  500. }
  501.  
  502. int dlp_FindDBInfo(int sd, int cardno, int start, char * dbname, unsigned long type, unsigned long creator, struct DBInfo * info)
  503. {
  504.   int i;
  505.   
  506.   /* This function does not match any DLP layer function, but is intended as
  507.      a shortcut for programs looking for databases. It uses a fairly
  508.      byzantine mechanism for ordering the RAM databases before the ROM ones.
  509.      You must feed the "index" slot from the returned info in as start the
  510.      next time round. */
  511.   
  512.   if (start < 0x1000) {
  513.     i=start;
  514.     while(dlp_ReadDBList(sd, cardno, 0x80, i, info)>0) {
  515.       if( 
  516.          ((!dbname) || (strcmp(info->name,dbname)==0)) &&
  517.          ((!type) || (info->type==type)) &&
  518.          ((!creator) || (info->creator==creator))
  519.         )
  520.         goto found;
  521.       i=info->index+1;
  522.     }
  523.     start = 0x1000;
  524.   }
  525.   
  526.   i=start & 0xFFF;
  527.   while(dlp_ReadDBList(sd, cardno, 0x40, i, info)>0) {
  528.     if( 
  529.        ((!dbname) || (strcmp(info->name,dbname)==0)) &&
  530.        ((!type) || (info->type==type)) &&
  531.        ((!creator) || (info->creator==creator))
  532.       ) {
  533.       info->index |= 0x1000;
  534.       goto found;
  535.     }
  536.     i=info->index+1;
  537.   }
  538.   
  539.   return -1;
  540.  
  541. found:
  542.  
  543.   return 0;
  544. }
  545.  
  546. int dlp_OpenDB(int sd, int cardno, int mode, char * name, int * dbhandle)
  547. {
  548.   unsigned char handle;
  549.   int result;
  550.  
  551.   dlp_buf[0] = (unsigned char)cardno;
  552.   dlp_buf[1] = (unsigned char)mode;
  553.   strcpy((char*)dlp_buf+2, name);
  554.  
  555.   Trace(OpenDB);
  556.  
  557. #ifdef DLP_TRACE  
  558.   if (dlp_trace) {  
  559.     fprintf(stderr, " Wrote: Cardno: %d, Name: '%s', Mode:", cardno, name);
  560.     if (mode & dlpOpenRead)
  561.       fprintf(stderr, " Read");
  562.     if (mode & dlpOpenWrite)
  563.       fprintf(stderr, " Write");
  564.     if (mode & dlpOpenExclusive)
  565.       fprintf(stderr, " Exclusive");
  566.     if (mode & dlpOpenSecret)
  567.       fprintf(stderr, " Secret");
  568.     if (!mode)
  569.       fprintf(stderr, " None");
  570.     fprintf(stderr, " (0x%2.2X)\n", mode);
  571.   }
  572. #endif
  573.   
  574.   result = dlp_exec(sd, 0x17, 0x20, &dlp_buf[0], strlen(name)+3, &handle, 1);
  575.   
  576.   Expect(1);
  577.   
  578.   *dbhandle = (int)handle;
  579.  
  580. #ifdef DLP_TRACE  
  581.   if (dlp_trace) {  
  582.     fprintf(stderr, "  Read: Handle: %d\n", (int)handle);
  583.   }
  584. #endif
  585.   
  586.   return result;
  587. }
  588.  
  589.  
  590.  
  591. int dlp_DeleteDB(int sd, int card, const char * name)
  592. {
  593.   int result;
  594.   
  595.   dlp_buf[0] = (unsigned char)card;
  596.   dlp_buf[1] = (unsigned char)0;
  597.   strcpy((char*)dlp_buf+2, name);
  598.  
  599.   Trace(DeleteDB);
  600.  
  601. #ifdef DLP_TRACE  
  602.   if (dlp_trace) {  
  603.     fprintf(stderr, " Wrote: Cardno: %d, Name: '%s'\n", card, name);
  604.   }
  605. #endif
  606.   
  607.   result = dlp_exec(sd, 0x1A, 0x20, dlp_buf, 2+strlen(name)+1, 0, 0);
  608.   
  609.   Expect(0);
  610.   
  611.   return result;
  612. }
  613.  
  614. int dlp_CreateDB(int sd, long creator, long type, int cardno, 
  615.                  int flags, int version, const char * name, int * dbhandle)
  616. {
  617.   unsigned char handle;
  618.   int result;
  619.  
  620.   set_long(dlp_buf, creator);
  621.   set_long(dlp_buf+4, type);
  622.   set_byte(dlp_buf+8, cardno);
  623.   set_byte(dlp_buf+9, 0);
  624.   set_short(dlp_buf+10, flags);
  625.   set_short(dlp_buf+12, version);
  626.   strcpy((char*)dlp_buf+14, name);
  627.   
  628.   Trace(CreateDB);
  629.  
  630. #ifdef DLP_TRACE  
  631.   if (dlp_trace) {  
  632.     fprintf(stderr, " Wrote: Card: %d, version: %d, name '%s'\n", cardno, version, name);
  633.     fprintf(stderr, "        DB Flags:");
  634.     if (flags & dlpDBFlagResource)
  635.       fprintf(stderr, " Resource");
  636.     if (flags & dlpDBFlagReadOnly)
  637.       fprintf(stderr, " ReadOnly");
  638.     if (flags & dlpDBFlagAppInfoDirty)
  639.       fprintf(stderr, " AppInfoDirty");
  640.     if (flags & dlpDBFlagBackup)
  641.       fprintf(stderr, " Backup");
  642.     if (flags & dlpDBFlagReset)
  643.       fprintf(stderr, " Reset");
  644.     if (flags & dlpDBFlagNewer)
  645.       fprintf(stderr, " Newer");
  646.     if (flags & dlpDBFlagOpen)
  647.       fprintf(stderr, " Open");
  648.     if (!flags)
  649.       fprintf(stderr, " None");
  650.     fprintf(stderr, " (0x%2.2X), Creator: '%s'", flags, printlong(creator));
  651.     fprintf(stderr, ", Type: '%s'\n", printlong(type));
  652.   }
  653. #endif  
  654.  
  655.   result = dlp_exec(sd, 0x18, 0x20, dlp_buf, 14+strlen(name)+1, &handle, 1);
  656.   
  657.   Expect(1);
  658.   
  659.   if (dbhandle)
  660.     *dbhandle = (int)handle;
  661.  
  662. #ifdef DLP_TRACE
  663.   if (dlp_trace) {  
  664.     fprintf(stderr, "  Read: Handle: %d\n", (int)handle);
  665.   }
  666. #endif
  667.  
  668.   return result;
  669. }
  670.  
  671.  
  672. int dlp_CloseDB(int sd, int dbhandle)
  673. {
  674.   unsigned char handle = (unsigned char)dbhandle;
  675.   int result;
  676.  
  677.   Trace(CloseDB);
  678.  
  679. #ifdef DLP_TRACE  
  680.   if (dlp_trace) {  
  681.     fprintf(stderr, " Wrote: Handle: %d\n", dbhandle);
  682.   }
  683. #endif
  684.   
  685.   result = dlp_exec(sd, 0x19, 0x20, &handle, 1, 0, 0);
  686.  
  687.   Expect(0);
  688.   
  689.   return result;
  690. }
  691.  
  692. int dlp_CloseDB_All(int sd)
  693. {
  694.   int result;
  695.  
  696.   Trace(CloseDB_all);
  697.   
  698.   result = dlp_exec(sd, 0x19, 0x21, 0, 0, 0, 0);
  699.   
  700.   Expect(0);
  701.   
  702.   return result;
  703. }
  704.  
  705. int dlp_CallApplication(int sd, unsigned long creator, unsigned long type, int action, 
  706.                         int length, void * data,
  707.                         unsigned long * retcode, int maxretlen, int * retlen, void * retdata)
  708. {
  709.   int result;
  710.   int version = pi_version(sd);
  711.   
  712.   if (version >= 0x0101) { /* PalmOS 2.0 call encoding */
  713.     set_long(dlp_buf+0, creator);
  714.     set_long(dlp_buf+4, type);
  715.     set_short(dlp_buf+8, action);
  716.     set_long(dlp_buf+10, length);
  717.     set_long(dlp_buf+14, 0);
  718.     set_long(dlp_buf+18, 0);
  719.     
  720.     if (length+22 > DLP_BUF_SIZE) {
  721.         fprintf(stderr, "Data too large\n");
  722.         return -131;
  723.     }
  724.     
  725.     memcpy(dlp_buf+22, data, length);
  726.  
  727.     Trace(CallApplicationV2);
  728.  
  729. #ifdef DLP_TRACE  
  730.     if (dlp_trace) {  
  731.       fprintf(stderr, " Wrote: Creator: '%s',", printlong(creator));
  732.       fprintf(stderr, " Type: '%s', Action code: %d, and %d bytes of data:\n",
  733.         printlong(type), action, length);
  734.       dumpdata(data, length);
  735.     }
  736. #endif
  737.  
  738.     result = dlp_exec(sd, 0x28, 0x21, dlp_buf, 22 + length, dlp_buf, 0xffff);
  739.   
  740.     Expect(16);
  741.   
  742.     if (retcode)
  743.       *retcode = get_long(dlp_buf);
  744.     
  745.     result -= 16;
  746.   
  747.     if (retlen)
  748.       *retlen = result;
  749.     if (retdata)
  750.       memcpy(retdata, dlp_buf+16, result > maxretlen ? maxretlen : result);
  751.   
  752. #ifdef DLP_TRACE  
  753.     if (dlp_trace) {  
  754.       fprintf(stderr, "  Read: Result: %lu (0x%8.8lX), and %d bytes:\n",
  755.         get_long(dlp_buf), get_long(dlp_buf+4), result);
  756.       dumpdata(dlp_buf+16,result);
  757.     }
  758. #endif
  759.   
  760.     return result;
  761.  
  762.  
  763.   } else { /* PalmOS 1.0 call encoding */
  764.     set_long(dlp_buf+0, creator);
  765.     set_short(dlp_buf+4, action);
  766.     set_short(dlp_buf+6, length);
  767.     memcpy(dlp_buf+6, data, length);
  768.  
  769.     Trace(CallApplicationV10);
  770.  
  771. #ifdef DLP_TRACE
  772.     if (dlp_trace) {  
  773.       fprintf(stderr, " Wrote: Creator: '%s', Action code: %d, and %d bytes of data:\n",
  774.         printlong(creator), action, length);
  775.       dumpdata(data, length);
  776.     }
  777. #endif
  778.  
  779.     result = dlp_exec(sd, 0x28, 0x20 , dlp_buf, 8, dlp_buf, 0xffff);
  780.   
  781.     Expect(6);
  782.   
  783.     if (retcode)
  784.       *retcode = get_short(dlp_buf+2);
  785.     
  786.     result -= 6;
  787.   
  788.     if (retlen)
  789.       *retlen = result;
  790.     if (retdata)
  791.       memcpy(retdata, dlp_buf+6, result > maxretlen ? maxretlen : result);
  792.   
  793. #ifdef DLP_TRACE  
  794.     if (dlp_trace) {  
  795.       fprintf(stderr, "  Read: Action: %d, Result: %d (0x%4.4X), and %d bytes:\n",
  796.         get_short(dlp_buf), get_short(dlp_buf+2), get_short(dlp_buf+2), result);
  797.       dumpdata(dlp_buf+6, result);
  798.     }
  799. #endif
  800.   
  801.     return result;
  802.  
  803.   }  
  804.   
  805. }
  806.  
  807. int dlp_ResetSystem(int sd)
  808. {
  809.   int result;
  810.  
  811.   Trace(ResetSystem);
  812.   
  813.   result = dlp_exec(sd, 0x29, 0, 0, 0, 0, 0);
  814.   
  815.   Expect(0);
  816.  
  817.   return result;
  818. }
  819.  
  820. int dlp_AddSyncLogEntry(int sd, char * entry)
  821. { 
  822.   int result;
  823.  
  824.   Trace(AddSyncLogEntry);
  825.   
  826. #ifdef DLP_TRACE  
  827.   if (dlp_trace) {  
  828.     fprintf(stderr," Wrote: Entry:\n");
  829.     dumpdata((unsigned char *)entry,strlen(entry));
  830.   }
  831. #endif
  832.  
  833.   result = dlp_exec(sd, 0x2A, 0x20, (unsigned char*)entry, strlen(entry), 0, 0);
  834.  
  835.   Expect(0);
  836.   
  837.   return result;
  838. }
  839.  
  840. int dlp_ReadOpenDBInfo(int sd, int dbhandle, int * records)
  841. {
  842.   unsigned char buf[2];
  843.   int result;
  844.  
  845.   Trace(ReadOpenDBInfo);
  846.  
  847. #ifdef DLP_TRACE
  848.   if (dlp_trace) {  
  849.     fprintf(stderr, " Wrote: Handle: %d\n", dbhandle);
  850.   }
  851. #endif
  852.   
  853.   set_byte(dlp_buf, (unsigned char)dbhandle);
  854.   result = dlp_exec(sd, 0x2B, 0x20, dlp_buf, 1, buf, 2);
  855.  
  856.   Expect(2);
  857.   
  858.   if (records)
  859.     *records = get_short(buf);
  860.       
  861. #ifdef DLP_TRACE
  862.   if (dlp_trace) {  
  863.     fprintf(stderr, "  Read: %d records\n", get_short(buf));
  864.   }
  865. #endif
  866.   
  867.   return result;
  868. }
  869.  
  870. int dlp_MoveCategory(int sd, int handle, int fromcat, int tocat)
  871. {
  872.   int result;
  873.   
  874.   set_byte(dlp_buf+0, handle);
  875.   set_byte(dlp_buf+1, fromcat);
  876.   set_byte(dlp_buf+2, tocat);
  877.   set_byte(dlp_buf+3, 0);
  878.  
  879.   Trace(MoveCategory);
  880.  
  881. #ifdef DLP_TRACE  
  882.   if (dlp_trace) {  
  883.     fprintf(stderr, " Wrote: Handle: %d, From: %d, To: %d\n", handle, fromcat, tocat);
  884.   }
  885. #endif
  886.   
  887.   result = dlp_exec(sd, 0x2C, 0x20, dlp_buf, 4, 0, 0);
  888.   
  889.   Expect(0);
  890.   
  891.   return result;
  892. }
  893.  
  894.  
  895. int dlp_OpenConduit(int sd)
  896. {
  897.   int result;
  898.  
  899.   Trace(OpenConduit);
  900.  
  901.   result = dlp_exec(sd, 0x2E, 0, 0, 0, 0, 0);
  902.  
  903.   Expect(0);
  904.   
  905.   return result;
  906. }
  907.  
  908. int dlp_EndOfSync(int sd, int status)
  909. {
  910.   int result;
  911.   struct pi_socket * ps;
  912.   
  913.   set_short(dlp_buf, status);
  914.  
  915.   Trace(EndOfSync);
  916.   
  917.   result = dlp_exec(sd, 0x2F, 0x20, dlp_buf, 2, 0, 0);
  918.  
  919.   Expect(0);
  920.   
  921.   /* Messy code to set end-of-sync flag on socket 
  922.      so pi_close won't do it for us */
  923.   if (result == 0)
  924.     if ( (ps = find_pi_socket(sd)) )
  925.       ps->connected |= 2;
  926.   
  927.   return result;
  928. }
  929.  
  930. int dlp_AbortSync(int sd) {
  931.   struct pi_socket * ps;
  932.  
  933. #ifdef DLP_TRACE
  934.   if (dlp_trace) {  
  935.     fprintf(stderr, "DLP %d: AbortSync\nResult: Whatever\n", sd);
  936.   }
  937. #endif
  938.   
  939.   /* Set end-of-sync flag on socket so pi_close won't do a dlp_EndOfSync */
  940.   if ( (ps = find_pi_socket(sd)) )
  941.     ps->connected |= 2;
  942.  
  943.   return pi_close(sd);
  944. }
  945.  
  946. int dlp_WriteUserInfo(int sd, struct PilotUser *User)
  947. {
  948.   int result;
  949.  
  950.   Trace(WriteUserInfo);
  951.  
  952. #ifdef DLP_TRACE
  953.   if (dlp_trace) {  
  954.     fprintf(stderr, " Wrote: UID: 0x%8.8lX, VID: 0x%8.8lX, PCID: 0x%8.8lX\n", 
  955.       User->userID, User->viewerID, User->lastSyncPC);
  956.     fprintf(stderr, "        Last sync date: %s", ctime(&User->lastSyncDate));
  957.     fprintf(stderr, "        Successful sync date: %s", ctime(&User->successfulSyncDate));
  958.     fprintf(stderr, "        User name '%s'\n", User->username);
  959.   }
  960. #endif
  961.   
  962.   set_long(dlp_buf, User->userID);
  963.   set_long(dlp_buf+4, User->viewerID);
  964.   set_long(dlp_buf+8, User->lastSyncPC);
  965.   set_date(dlp_buf+12, User->lastSyncDate);
  966.   set_byte(dlp_buf+20, 0xff);
  967.   set_byte(dlp_buf+21, strlen(User->username)+1);
  968.   strcpy((char*)dlp_buf+22, User->username);
  969.  
  970.   result = dlp_exec(sd, 0x11, 0x20, dlp_buf, 22+strlen(User->username)+1, NULL, 0);
  971.   
  972.   Expect(0);
  973.   
  974.   return result;
  975. }
  976.                         
  977. int dlp_ReadUserInfo(int sd, struct PilotUser* User)
  978. {
  979.   int result;
  980.   int userlen;
  981.  
  982.   Trace(ReadUserInfo);
  983.  
  984.   result = dlp_exec(sd, 0x10, 0x00, NULL, 0, dlp_buf, DLP_BUF_SIZE);
  985.  
  986.   Expect(30);
  987.  
  988.   userlen = get_byte(dlp_buf+28);
  989.  
  990.   User->userID = get_long(dlp_buf);
  991.   User->viewerID = get_long(dlp_buf+4);
  992.   User->lastSyncPC = get_long(dlp_buf+8);
  993.   User->successfulSyncDate = get_date(dlp_buf+12);
  994.   User->lastSyncDate = get_date(dlp_buf+20);
  995.   User->passwordLength = get_byte(dlp_buf+29);
  996.   memcpy(User->username, dlp_buf+30, userlen);
  997.   User->username[userlen] = '\0';
  998.   memcpy(User->password, dlp_buf+30+userlen, User->passwordLength);
  999.  
  1000. #ifdef DLP_TRACE
  1001.   if (dlp_trace) {  
  1002.     fprintf(stderr, "  Read: UID: 0x%8.8lX, VID: 0x%8.8lX, PCID: 0x%8.8lX\n", 
  1003.       User->userID, User->viewerID, User->lastSyncPC);
  1004.     fprintf(stderr, "        Last sync date: %s", ctime(&User->lastSyncDate));
  1005.     fprintf(stderr, "        Successful sync date: %s", ctime(&User->successfulSyncDate));
  1006.     fprintf(stderr, "        User name '%s'", User->username);
  1007.     if (User->passwordLength) {
  1008.       fprintf(stderr, ", Password of %d bytes:\n", User->passwordLength);
  1009.       dumpdata((unsigned char *)User->password,User->passwordLength);
  1010.     }
  1011.     else
  1012.       fprintf(stderr, ", No password\n");
  1013.   }
  1014. #endif
  1015.  
  1016.   return result;
  1017. }
  1018.  
  1019. int dlp_ReadNetSyncInfo(int sd, struct NetSyncInfo * i)
  1020. {
  1021.   int result;
  1022.   int p;
  1023.   
  1024.   if (pi_version(sd)<0x0101)
  1025.     return -129; /* This call only functions under PalmOS 2.0 */
  1026.  
  1027.   Trace(ReadNetSyncInfo);
  1028.  
  1029.   result = dlp_exec(sd, 0x36, 0x20, NULL, 0, dlp_buf, DLP_BUF_SIZE);
  1030.  
  1031.   Expect(24);
  1032.   
  1033.  
  1034.   i->lanSync = get_byte(dlp_buf);
  1035.   p = 24;
  1036.  
  1037.   i->hostName[0] = 0;
  1038.   memcpy(i->hostName, dlp_buf+p, get_short(dlp_buf+18));
  1039.   p += get_short(dlp_buf+18);
  1040.  
  1041.   i->hostAddress[0] = 0;
  1042.   memcpy(i->hostAddress, dlp_buf+p, get_short(dlp_buf+20));
  1043.   p += get_short(dlp_buf+20);
  1044.  
  1045.   i->hostSubnetMask[0] = 0;
  1046.   memcpy(i->hostSubnetMask, dlp_buf+p, get_short(dlp_buf+22));
  1047.   p += get_short(dlp_buf+22);
  1048.  
  1049. #ifdef DLP_TRACE
  1050.   if (dlp_trace) {  
  1051.     fprintf(stderr, "  Read: Active: %d\n", get_byte(dlp_buf));
  1052.     fprintf(stderr, "        PC hostname: '%s', address '%s', mask '%s'\n",
  1053.       i->hostName, i->hostAddress, i->hostSubnetMask);
  1054.   }
  1055. #endif
  1056.  
  1057.   return result;
  1058. }
  1059.  
  1060. int dlp_WriteNetSyncInfo(int sd, struct NetSyncInfo * i)
  1061. {
  1062.   int result;
  1063.   int p;
  1064.   
  1065.   if (pi_version(sd)<0x0101)
  1066.     return -129;
  1067.  
  1068.   Trace(WriteNetSyncInfo);
  1069.  
  1070. #ifdef DLP_TRACE
  1071.   if (dlp_trace) {  
  1072.     fprintf(stderr, "  Wrote: Active: %d\n", get_byte(dlp_buf));
  1073.     fprintf(stderr, "        PC hostname: '%s', address '%s', mask '%s'\n",
  1074.       i->hostName, i->hostAddress, i->hostSubnetMask);
  1075.   }
  1076. #endif
  1077.   
  1078.   set_byte(dlp_buf, 0x80|0x40|0x20|0x10); /* Change all settings */
  1079.   set_byte(dlp_buf+1, i->lanSync);
  1080.   set_long(dlp_buf+2, 0);  /* Reserved1 */
  1081.   set_long(dlp_buf+6, 0);  /* Reserved2 */
  1082.   set_long(dlp_buf+10, 0); /* Reserved3 */
  1083.   set_long(dlp_buf+14, 0); /* Reserved4 */
  1084.   set_short(dlp_buf+18, strlen(i->hostName)+1);
  1085.   set_short(dlp_buf+20, strlen(i->hostAddress)+1);
  1086.   set_short(dlp_buf+22, strlen(i->hostSubnetMask)+1);
  1087.   p = 24;
  1088.   strcpy((char *)dlp_buf+p, i->hostName);
  1089.   p += strlen(i->hostName)+1;
  1090.   strcpy((char *)dlp_buf+p, i->hostAddress);
  1091.   p += strlen(i->hostAddress)+1;
  1092.   strcpy((char *)dlp_buf+p, i->hostSubnetMask);
  1093.   p += strlen(i->hostSubnetMask)+1;
  1094.   
  1095.   result = dlp_exec(sd, 0x37, 0x20, dlp_buf, p, dlp_buf, DLP_BUF_SIZE);
  1096.  
  1097.   Expect(0);
  1098.  
  1099.   return result;
  1100. }
  1101.  
  1102. int dlp_RPC(int sd, struct RPC_params * p, unsigned long * result)
  1103. {
  1104.   int i;
  1105.   unsigned char * c;
  1106.   
  1107.   /* RPC through DLP breaks all the rules and isn't well documented to boot */
  1108.   
  1109.   long D0=0,A0=0;
  1110.   int err;
  1111.   
  1112.   dlp_buf[0] = 0x2D;
  1113.   dlp_buf[1] = 1;
  1114.   dlp_buf[2] = 0; /* Unknown filler */
  1115.   dlp_buf[3] = 0;
  1116.  
  1117.   InvertRPC(p);
  1118.   
  1119.   set_short(dlp_buf+4, p->trap);
  1120.   set_long(dlp_buf+6, D0);
  1121.   set_long(dlp_buf+10, A0);
  1122.   set_short(dlp_buf+14, p->args);
  1123.     
  1124.   c = dlp_buf+16;
  1125.   for(i=p->args-1;i>=0;i--) {
  1126.     set_byte(c, p->param[i].byRef); c++;
  1127.     set_byte(c, p->param[i].size); c++;
  1128.     if(p->param[i].data)
  1129.       memcpy(c, p->param[i].data, p->param[i].size);
  1130.     c += p->param[i].size;
  1131.     if(p->param[i].size & 1)
  1132.       *c++ = 0;
  1133.   }
  1134.  
  1135.   pi_write(sd, dlp_buf, c-dlp_buf);
  1136.   
  1137.   err = 0;
  1138.   
  1139.   if(p->reply) {
  1140.     int l = pi_read(sd, dlp_buf, c-dlp_buf+2);
  1141.  
  1142.     if (l < 0)
  1143.       err = l;
  1144.     else if (l < 6) 
  1145.       err = -1;
  1146.     else if (dlp_buf[0] != 0xAD)
  1147.       err = -2;
  1148.     else if (get_short(dlp_buf+2))
  1149.       err = -get_short(dlp_buf+2);
  1150.     else {
  1151.       D0 = get_long(dlp_buf+8);
  1152.       A0 = get_long(dlp_buf+12);
  1153.       c = dlp_buf+18;
  1154.       for(i=p->args-1;i>=0;i--) {
  1155.         if(p->param[i].byRef && p->param[i].data)
  1156.           memcpy(p->param[i].data, c+2, p->param[i].size);
  1157.         c += 2 + ((p->param[i].size+1)& ~1);
  1158.       }
  1159.     }
  1160.   }
  1161.   
  1162.   UninvertRPC(p);
  1163.   
  1164.   if (result)
  1165.     if(p->reply==RPC_PtrReply)
  1166.       *result = A0;
  1167.     else if (p->reply==RPC_IntReply)
  1168.       *result = D0;
  1169.   
  1170.   return err;
  1171. }
  1172.  
  1173. int dlp_ReadFeature(int sd, unsigned long creator, unsigned int num, unsigned long * feature)
  1174. {
  1175.   int result;
  1176.   
  1177.   if (pi_version(sd)<0x0101) {
  1178.     struct RPC_params p;
  1179.     
  1180.     Trace(ReadFeatureV1);
  1181.  
  1182.     if (feature) {
  1183.       int val;
  1184.       unsigned long result;
  1185.  
  1186. #ifdef DLP_TRACE
  1187.       if (dlp_trace) {  
  1188.         fprintf(stderr, " Wrote: Creator: '%s', Number: %d\n", 
  1189.           printlong(creator), num);
  1190.       }
  1191. #endif
  1192.  
  1193.       *feature = 0x12345678;
  1194.  
  1195.       PackRPC(&p, 0xA27B, RPC_IntReply, 
  1196.          RPC_Long(creator), RPC_Short(num), RPC_LongPtr(feature), RPC_End);
  1197.       
  1198.       val = dlp_RPC(sd, &p, &result);
  1199.       
  1200.  
  1201. #ifdef DLP_TRACE
  1202.       if (dlp_trace) {  
  1203.         if (val < 0)
  1204.           fprintf(stderr, "Result: Error: %s (%d)\n", dlp_errorlist[-val], val); 
  1205.         else if (result)
  1206.           fprintf(stderr, "FtrGet error 0x%8.8lX\n", (unsigned long)result);
  1207.         else
  1208.           fprintf(stderr, "  Read: Feature: 0x%8.8lX\n", (unsigned long)*feature);
  1209.       }
  1210. #endif
  1211.       
  1212.       if (val < 0)
  1213.         return val;
  1214.       if (result)
  1215.         return -result;
  1216.     }
  1217.     
  1218.     return 0;
  1219.   }    
  1220.  
  1221.   Trace(ReadFeatureV2);
  1222.  
  1223. #ifdef DLP_TRACE
  1224.   if (dlp_trace) {  
  1225.     fprintf(stderr, " Wrote: Creator: '%s', Number: %d\n", 
  1226.       printlong(creator), num);
  1227.   }
  1228. #endif
  1229.   
  1230.   set_long(dlp_buf, creator);
  1231.   set_short(dlp_buf+4, num);
  1232.   
  1233.   result = dlp_exec(sd, 0x38, 0x20, dlp_buf, 6, dlp_buf, DLP_BUF_SIZE);
  1234.  
  1235.   Expect(4);
  1236.  
  1237.   if (feature)
  1238.     *feature = (unsigned long)get_long(dlp_buf);
  1239.  
  1240. #ifdef DLP_TRACE
  1241.   if (dlp_trace) {  
  1242.     fprintf(stderr, "  Read: Feature: 0x%8.8lX\n", (unsigned long)get_long(dlp_buf));
  1243.   }
  1244. #endif
  1245.  
  1246.   return result;
  1247. }
  1248.  
  1249. int dlp_ResetLastSyncPC(int sd)
  1250. {
  1251.   struct PilotUser U;
  1252.   int err;
  1253.   
  1254.   if ((err = dlp_ReadUserInfo(sd, &U))<0)
  1255.     return err;
  1256.   U.lastSyncPC = 0;
  1257.   return dlp_WriteUserInfo(sd, &U);
  1258. }
  1259.  
  1260. int dlp_ResetDBIndex(int sd, int dbhandle)
  1261. {
  1262.   int result;
  1263.   struct pi_socket * ps;
  1264.  
  1265.   if ((ps = find_pi_socket(sd)))
  1266.     ps->dlprecord=0;
  1267.  
  1268.   Trace(ResetDBIndex);
  1269.  
  1270. #ifdef DLP_TRACE
  1271.   if (dlp_trace) {  
  1272.     fprintf(stderr, " Wrote: Handle: %d\n", dbhandle);
  1273.   }
  1274. #endif
  1275.   
  1276.   result = dlp_exec(sd, 0x30, 0x20, dlp_buf, 1, NULL, 0);
  1277.   
  1278.   Expect(0);
  1279.  
  1280.   return result;
  1281. }
  1282.  
  1283.  
  1284. int dlp_ReadRecordIDList(int sd, int dbhandle, int sort, 
  1285.                          int start, int max, recordid_t * IDs, int *count)
  1286. {
  1287.   int result, i, ret;
  1288.   unsigned int nbytes;
  1289.   unsigned char * p; 
  1290.   
  1291.   set_byte(dlp_buf,    dbhandle);
  1292.   set_byte(dlp_buf+1,  sort?0x80:0);
  1293.   set_short(dlp_buf+2, start);
  1294.   set_short(dlp_buf+4, max);
  1295.  
  1296.   Trace(ReadRecordIDList);
  1297.  
  1298. #ifdef DLP_TRACE
  1299.   if (dlp_trace) {  
  1300.     fprintf(stderr, " Wrote: Handle: %d, Sort: %s, Start: %d, Max: %d\n",
  1301.       dbhandle, sort ? "Yes" : "No", start, max);
  1302.   }
  1303. #endif
  1304.  
  1305.   nbytes = max * 4 + 2;
  1306.   if (nbytes > DLP_BUF_SIZE)
  1307.     nbytes = DLP_BUF_SIZE;
  1308.   
  1309.   result = dlp_exec(sd, 0x31, 0x20, dlp_buf, 6, dlp_buf, nbytes);
  1310.   
  1311.   Expect(2);
  1312.   
  1313.   ret = get_short(dlp_buf);
  1314.  
  1315. #ifdef DLP_TRACE
  1316.   if (dlp_trace) {  
  1317.     fprintf(stderr, " Read: %d IDs:\n", ret);
  1318.       dumpdata(dlp_buf+2, ret*4);
  1319.   }
  1320. #endif
  1321.  
  1322.   for (i = 0, p = dlp_buf+2; i < ret; i++, p+=4)
  1323.     IDs[i] = get_long(p);
  1324.   
  1325.   if (count)
  1326.     *count = i;
  1327.   
  1328.   return nbytes;
  1329. }
  1330.  
  1331. int dlp_WriteRecord(int sd, int dbhandle, int flags,
  1332.                  recordid_t recID, int catID, void* data, int length, recordid_t * NewID)
  1333. {
  1334.   unsigned char buf[4];
  1335.   int result;
  1336.  
  1337.   set_byte(dlp_buf, dbhandle);
  1338.   set_byte(dlp_buf+1, 0);
  1339.   set_long(dlp_buf+2, recID);
  1340.   set_byte(dlp_buf+6, flags);
  1341.   set_byte(dlp_buf+7, catID);
  1342.   
  1343.   if(length == -1)
  1344.       length = strlen((char*)data)+1;
  1345.  
  1346.   if (length+8 > DLP_BUF_SIZE) {
  1347.     fprintf(stderr, "Data too large\n");
  1348.     return -131;
  1349.   }
  1350.       
  1351.   memcpy(dlp_buf+8, data, length);
  1352.  
  1353.   Trace(WriteRecord);
  1354.  
  1355. #ifdef DLP_TRACE
  1356.   if (dlp_trace) {  
  1357.     fprintf(stderr, " Wrote: Handle: %d, RecordID: 0x%8.8lX, Category: %d\n",
  1358.       dbhandle, (unsigned long)recID, catID);
  1359.     fprintf(stderr, "        Flags:");
  1360.     if (flags & dlpRecAttrDeleted)
  1361.       fprintf(stderr, " Deleted");
  1362.     if (flags & dlpRecAttrDirty)
  1363.       fprintf(stderr, " Dirty");
  1364.     if (flags & dlpRecAttrBusy)
  1365.       fprintf(stderr, " Busy");
  1366.     if (flags & dlpRecAttrSecret)
  1367.       fprintf(stderr, " Secret");
  1368.     if (flags & dlpRecAttrArchived)
  1369.       fprintf(stderr, " Archive");
  1370.     if (!flags)
  1371.       fprintf(stderr, " None");
  1372.     fprintf(stderr, " (0x%2.2X), and %d bytes of data: \n", flags, length);
  1373.     dumpdata(data, length);
  1374.   }
  1375. #endif
  1376.  
  1377.   result = dlp_exec(sd, 0x21, 0x20, dlp_buf, 8+length, buf, 4);
  1378.   
  1379.   Expect(4);
  1380.   
  1381.   if(NewID)
  1382.     if(result == 4)
  1383.       *NewID = get_long(buf); /* New record ID */
  1384.     else
  1385.       *NewID = 0;
  1386.  
  1387. #ifdef DLP_TRACE
  1388.   if (dlp_trace) {  
  1389.     fprintf(stderr, "  Read: Record ID: 0x%8.8lX\n", (unsigned long)get_long(buf));
  1390.   }
  1391. #endif
  1392.       
  1393.   return result;
  1394. }
  1395.  
  1396. int dlp_DeleteRecord(int sd, int dbhandle, int all, recordid_t recID)
  1397. {
  1398.   int result;
  1399.   int flags = all ? 0x80 : 0;
  1400.  
  1401.   set_byte(dlp_buf, dbhandle);
  1402.   set_byte(dlp_buf+1, flags);
  1403.   set_long(dlp_buf+2, recID);
  1404.   
  1405.   Trace(DeleteRecord);
  1406.  
  1407. #ifdef DLP_TRACE
  1408.   if (dlp_trace) {  
  1409.     fprintf(stderr, " Wrote: Handle: %d, RecordID: %8.8lX, All: %s\n",
  1410.       dbhandle, (unsigned long)recID, all ? "Yes" : "No");
  1411.   }
  1412. #endif
  1413.   
  1414.   result = dlp_exec(sd, 0x22, 0x20, dlp_buf, 6, 0, 0);
  1415.   
  1416.   Expect(0);
  1417.   
  1418.   return result;
  1419. }
  1420.  
  1421. int dlp_DeleteCategory(int sd, int dbhandle, int category)
  1422. {
  1423.   int result;
  1424.   int flags = 0x40;
  1425.   
  1426.   if (pi_version(sd) < 0x0101) {
  1427.     /* Emulate if not connected to PalmOS 2.0 */
  1428.     int i,r,cat,attr;
  1429.     recordid_t id;
  1430.  
  1431.     Trace(DeleteCategoryV1);
  1432.  
  1433. #ifdef DLP_TRACE
  1434.     if (dlp_trace) {  
  1435.       fprintf(stderr, " Emulating with: Handle: %d, Category: %d\n",
  1436.         dbhandle, category & 0xff);
  1437.     }
  1438. #endif
  1439.  
  1440.     for(i=0;dlp_ReadRecordByIndex(sd, dbhandle, i, NULL, &id, NULL, &attr, &cat)>=0;i++) {
  1441.       if ((cat != category) || (attr & dlpRecAttrDeleted) || (attr & dlpRecAttrArchived)) 
  1442.         continue;
  1443.       r = dlp_DeleteRecord(sd, dbhandle, 0, id);
  1444.       if (r<0)
  1445.         return r;
  1446.       i--; /* Sigh, deleting the record moves it to the end. */
  1447.     }
  1448.     return 0;
  1449.   }
  1450.  
  1451.   set_byte(dlp_buf, dbhandle);
  1452.   set_byte(dlp_buf+1, flags);
  1453.   set_long(dlp_buf+2, category & 0xff);
  1454.   
  1455.   Trace(DeleteCategoryV2);
  1456.  
  1457. #ifdef DLP_TRACE
  1458.   if (dlp_trace) {  
  1459.     fprintf(stderr, " Wrote: Handle: %d, Category: %d\n",
  1460.       dbhandle, category & 0xff);
  1461.   }
  1462. #endif
  1463.   
  1464.   result = dlp_exec(sd, 0x22, 0x20, dlp_buf, 6, 0, 0);
  1465.   
  1466.   Expect(0);
  1467.   
  1468.   return result;
  1469. }
  1470.  
  1471.  
  1472. int dlp_ReadResourceByType(int sd, int fHandle, unsigned long type, int id, void* buffer, 
  1473.                           int* index, int* size)
  1474. {
  1475.   int result;
  1476.   
  1477.   set_byte(dlp_buf, fHandle);
  1478.   set_byte(dlp_buf+1, 0x00);
  1479.   set_long(dlp_buf+2, type);
  1480.   set_short(dlp_buf+6, id);
  1481.   set_short(dlp_buf+8, 0); /* Offset into record */
  1482.   set_short(dlp_buf+10, buffer ? DLP_BUF_SIZE : 0); /* length to return */
  1483.  
  1484.   Trace(ReadResourceByType);
  1485.  
  1486. #ifdef DLP_TRACE
  1487.   if (dlp_trace) {  
  1488.     fprintf(stderr, " Wrote: Handle: %d, Type: '%s', ID: %d\n",
  1489.       fHandle, printlong(type), id);
  1490.   }
  1491. #endif
  1492.  
  1493.   result = dlp_exec(sd, 0x23, 0x21, dlp_buf, 12, dlp_buf, DLP_BUF_SIZE);
  1494.   
  1495.   Expect(10);
  1496.  
  1497. #ifdef DLP_TRACE
  1498.   if (dlp_trace) {  
  1499.     fprintf(stderr, "  Read: Type: '%s', ID: %d, Index: %d, and %d bytes:\n",
  1500.       printlong(type), id, get_short(dlp_buf+6), result-10);
  1501.     dumpdata(dlp_buf+10, result-10);
  1502.   }
  1503. #endif
  1504.   
  1505.   if (index)
  1506.     *index = get_short(dlp_buf+6);
  1507.   if (size)
  1508.     *size = get_short(dlp_buf+8);
  1509.   if (buffer)
  1510.     memcpy(buffer, dlp_buf+10, result-10);
  1511.  
  1512.   return result-10;
  1513. }
  1514.  
  1515. int dlp_ReadResourceByIndex(int sd, int fHandle, int index, void* buffer,
  1516.                           unsigned long* type, int * id, int* size)
  1517. {
  1518.   int result;
  1519.   
  1520.   set_byte(dlp_buf, fHandle);
  1521.   set_byte(dlp_buf+1, 0x00);
  1522.   set_short(dlp_buf+2, index);
  1523.   set_short(dlp_buf+4, 0); /* Offset into record */
  1524.   set_short(dlp_buf+6, buffer ? DLP_BUF_SIZE : 0); /* length to return */
  1525.  
  1526.   Trace(ReadResourceByIndex);
  1527.  
  1528. #ifdef DLP_TRACE
  1529.   if (dlp_trace) {  
  1530.     fprintf(stderr, " Wrote: Handle: %d, Index: %d\n",
  1531.       fHandle, index);
  1532.   }
  1533. #endif
  1534.  
  1535.   result = dlp_exec(sd, 0x23, 0x20, dlp_buf, 8, dlp_buf, DLP_BUF_SIZE);
  1536.   
  1537.   Expect(10);
  1538.  
  1539. #ifdef DLP_TRACE
  1540.   if (dlp_trace) {  
  1541.     fprintf(stderr, "  Read: Type: '%s', ID: %d, Index: %d, and %d bytes:\n",
  1542.       printlong(get_long(dlp_buf)), get_short(dlp_buf+4), index, result-10);
  1543.     dumpdata(dlp_buf+10, result-10);
  1544.   }
  1545. #endif
  1546.  
  1547.   if (type) 
  1548.     *type = get_long(dlp_buf);
  1549.   if (id)
  1550.     *id = get_short(dlp_buf+4);
  1551.   if (size)
  1552.     *size = get_short(dlp_buf+8);
  1553.   if (buffer)
  1554.     memcpy(buffer, dlp_buf+10, result-10);
  1555.    
  1556.   return result-10;
  1557. }
  1558.  
  1559. int dlp_WriteResource(int sd, int dbhandle, unsigned long type, int id,
  1560.                  const void* data, int length)
  1561. {
  1562.   int result;
  1563.   
  1564.   set_byte(dlp_buf, dbhandle);
  1565.   set_byte(dlp_buf+1, 0);
  1566.   set_long(dlp_buf+2, type);
  1567.   set_short(dlp_buf+6, id);
  1568.   set_short(dlp_buf+8, length);
  1569.  
  1570.   if (length+10 > DLP_BUF_SIZE) {
  1571.     fprintf(stderr, "Data too large\n");
  1572.     return -131;
  1573.   }
  1574.  
  1575.   memcpy(dlp_buf+10, data, length);
  1576.   
  1577.   Trace(WriteResource);
  1578.  
  1579. #ifdef DLP_TRACE
  1580.   if (dlp_trace) {  
  1581.     fprintf(stderr, " Wrote: Type: '%s', ID: %d, and %d bytes:\n",
  1582.       printlong(type), id, length);
  1583.     dumpdata(data, length);
  1584.   }
  1585. #endif
  1586.  
  1587.   result = dlp_exec(sd, 0x24, 0x20, dlp_buf, 10+length, NULL, 0);
  1588.   
  1589.   Expect(0);
  1590.   
  1591.   return result;
  1592. }
  1593.  
  1594. int dlp_DeleteResource(int sd, int dbhandle, int all, unsigned long restype, int resID)
  1595. {
  1596.   int result;
  1597.   int flags = all ? 0x80 : 0;
  1598.  
  1599.   set_byte(dlp_buf, dbhandle);
  1600.   set_byte(dlp_buf+1, flags);
  1601.   set_long(dlp_buf+2, restype);
  1602.   set_short(dlp_buf+6, resID);
  1603.  
  1604.   Trace(DeleteResource);
  1605.  
  1606. #ifdef DLP_TRACE
  1607.   if (dlp_trace) {  
  1608.     fprintf(stderr, " Wrote: Type: '%s', ID: %d, All: %s\n",
  1609.       printlong(restype), resID, all ? "Yes" : "No");
  1610.   }
  1611. #endif
  1612.   
  1613.   result = dlp_exec(sd, 0x25, 0x20, dlp_buf, 8, NULL, 0);
  1614.   
  1615.   Expect(0);
  1616.   
  1617.   return result;
  1618. }
  1619.  
  1620. int dlp_ReadAppBlock(int sd, int fHandle, int offset,
  1621.                            void* dbuf, int dlen)
  1622. {
  1623.   int result;
  1624.   
  1625.   set_byte(dlp_buf, fHandle);
  1626.   set_byte(dlp_buf+1, 0x00);
  1627.   set_short(dlp_buf+2, offset);
  1628.   set_short(dlp_buf+4, dlen);
  1629.   
  1630.   Trace(ReadAppBlock);
  1631.  
  1632. #ifdef DLP_TRACE
  1633.   if (dlp_trace) {  
  1634.     fprintf(stderr, " Wrote: Handle: %d, Offset: %d, Max Length: %d\n",
  1635.       fHandle, offset, dlen);
  1636.   }
  1637. #endif
  1638.   
  1639.   result = dlp_exec(sd, 0x1b, 0x20, dlp_buf, 6, dlp_buf, DLP_BUF_SIZE);
  1640.   
  1641.   Expect(2);
  1642.   
  1643.   if (dbuf)
  1644.     memcpy(dbuf, dlp_buf+2, result-2);
  1645.   
  1646. #ifdef DLP_TRACE
  1647.   if (dlp_trace) {  
  1648.     fprintf(stderr, "  Read: %d bytes:\n",
  1649.       result-2);
  1650.     dumpdata(dlp_buf+2, result-2);
  1651.   }
  1652. #endif
  1653.   
  1654.   return result-2;
  1655. }
  1656.  
  1657. int dlp_WriteAppBlock(int sd, int fHandle, const /*@unique@*/ void* data, int length)
  1658. {
  1659.   int result;
  1660.   
  1661.   set_byte(dlp_buf, fHandle);
  1662.   set_byte(dlp_buf+1, 0x00);
  1663.   set_short(dlp_buf+2, length);
  1664.  
  1665.   if (length+4 > DLP_BUF_SIZE) {
  1666.     fprintf(stderr, "Data too large\n");
  1667.     return -131;
  1668.   }
  1669.   
  1670.   memcpy(dlp_buf+4, data, length);
  1671.  
  1672.   Trace(WriteAppBlock);
  1673.  
  1674. #ifdef DLP_TRACE
  1675.   if (dlp_trace) {  
  1676.     fprintf(stderr, " Wrote: Handle: %d, %d bytes:\n",
  1677.       fHandle, length);
  1678.     dumpdata(data, length);
  1679.   }
  1680. #endif
  1681.  
  1682.   result = dlp_exec(sd, 0x1c, 0x20, dlp_buf, length+4, NULL, 0);
  1683.   
  1684.   Expect(0);
  1685.   
  1686.   return result;
  1687. }
  1688.  
  1689. int dlp_ReadSortBlock(int sd, int fHandle, int offset,
  1690.                            void* dbuf, int dlen)
  1691. {
  1692.   int result;
  1693.   
  1694.   set_byte(dlp_buf, fHandle);
  1695.   set_byte(dlp_buf+1, 0x00);
  1696.   set_short(dlp_buf+2, offset);
  1697.   set_short(dlp_buf+4, dlen);
  1698.  
  1699.   Trace(ReadSortBlock);
  1700.  
  1701. #ifdef DLP_TRACE
  1702.   if (dlp_trace) {  
  1703.     fprintf(stderr, " Wrote: Handle: %d, Offset: %d, Max Length: %d\n",
  1704.       fHandle, offset, dlen);
  1705.   }
  1706. #endif
  1707.   
  1708.   result = dlp_exec(sd, 0x1d, 0x20, dlp_buf, 6, dlp_buf, DLP_BUF_SIZE);
  1709.  
  1710. #ifdef DLP_TRACE
  1711.   if (dlp_trace) {  
  1712.     fprintf(stderr, "  Read: %d bytes:\n",
  1713.       result-2);
  1714.     dumpdata(dlp_buf+2, result-2);
  1715.   }
  1716. #endif
  1717.   
  1718.   if (dbuf)
  1719.     memcpy(dbuf, dlp_buf+2, result-2);
  1720.   return result-2;
  1721. }
  1722.  
  1723. int dlp_WriteSortBlock(int sd, int fHandle, const /*@unique@*/ void* data, int length)
  1724. {
  1725.   int result;
  1726.   set_byte(dlp_buf, fHandle);
  1727.   set_byte(dlp_buf+1, 0x00);
  1728.   set_short(dlp_buf+2, length);
  1729.  
  1730.   if (length+4 > DLP_BUF_SIZE) {
  1731.     fprintf(stderr, "Data too large\n");
  1732.     return -131;
  1733.   }
  1734.   
  1735.   memcpy(dlp_buf+4, data, length);
  1736.  
  1737.   Trace(WriteSortBlock);
  1738.  
  1739. #ifdef DLP_TRACE
  1740.   if (dlp_trace) {  
  1741.     fprintf(stderr, " Wrote: Handle: %d, %d bytes:\n",
  1742.       fHandle, length);
  1743.     dumpdata(data, length);
  1744.   }
  1745. #endif
  1746.  
  1747.   result = dlp_exec(sd, 0x1e, 0x20, dlp_buf, length+4, NULL, 0);
  1748.  
  1749.   Expect(0);
  1750.   
  1751.   return result;
  1752. }
  1753.  
  1754. int dlp_CleanUpDatabase(int sd, int fHandle)
  1755. {
  1756.   int result;
  1757.   unsigned char handle = fHandle;
  1758.  
  1759.   Trace(CleanUpDatabase);
  1760.  
  1761. #ifdef DLP_TRACE
  1762.   if (dlp_trace) {  
  1763.     fprintf(stderr, " Wrote: Handle: %d\n", fHandle);
  1764.   }
  1765. #endif
  1766.  
  1767.   result = dlp_exec(sd, 0x26, 0x20, &handle, 1, NULL, 0);
  1768.   
  1769.   Expect(0);
  1770.   
  1771.   return result;
  1772. }
  1773.  
  1774. int dlp_ResetSyncFlags(int sd, int fHandle)
  1775. {
  1776.   int result;
  1777.   unsigned char handle = fHandle;
  1778.  
  1779.   Trace(ResetSyncFlags);
  1780.  
  1781. #ifdef DLP_TRACE
  1782.   if (dlp_trace) {  
  1783.     fprintf(stderr, " Wrote: Handle: %d\n", fHandle);
  1784.   }
  1785. #endif
  1786.   
  1787.   result = dlp_exec(sd, 0x27, 0x20, &handle, 1, NULL, 0);
  1788.   
  1789.   Expect(0);
  1790.   
  1791.   return result;
  1792. }
  1793.  
  1794. int dlp_ReadNextRecInCategory(int sd, int fHandle, int incategory, void* buffer,
  1795.                           recordid_t* id, int* index, int* size, int* attr)
  1796. {
  1797.   int result;
  1798. #ifdef DLP_TRACE
  1799.   int flags;
  1800. #endif
  1801.  
  1802.   if (pi_version(sd) < 0x0101) {
  1803.     /* Emulate for PalmOS 1.0 */
  1804.     int cat;
  1805.     int r;
  1806.     struct pi_socket * ps;
  1807.  
  1808.     Trace(ReadNextRecInCategoryV1);
  1809.  
  1810. #ifdef DLP_TRACE
  1811.     if (dlp_trace) {  
  1812.       fprintf(stderr, " Emulating with: Handle: %d, Category: %d\n", fHandle, incategory);
  1813.     }
  1814. #endif
  1815.  
  1816.     if ((ps = find_pi_socket(sd))==0)
  1817.       return -130;
  1818.     
  1819.     for(;;) {
  1820.       /* Fetch next modified record (in any category) */
  1821.       r = dlp_ReadRecordByIndex(sd, fHandle, ps->dlprecord, 0, 0, 0, 0, &cat);
  1822.       
  1823.       if (r<0)
  1824.         break;
  1825.       
  1826.       if (cat != incategory) {
  1827.         ps->dlprecord++;
  1828.         continue;
  1829.       }
  1830.  
  1831.       r = dlp_ReadRecordByIndex(sd, fHandle, ps->dlprecord, buffer, id, size, attr, &cat);
  1832.       
  1833.       if (r >= 0) {
  1834.         if (index)
  1835.           *index = ps->dlprecord;
  1836.         ps->dlprecord++;
  1837.       } else {
  1838.         /* If none found, reset modified pointer so that another search on a different
  1839.            (or the same!) category will work */
  1840.         ps->dlprecord = 0;
  1841.       }
  1842.       
  1843.       break;
  1844.     }
  1845.     
  1846.     return r;
  1847.   }
  1848.  
  1849.   Trace(ReadNextRecInCategoryV2);
  1850.  
  1851.   set_byte(dlp_buf, fHandle);
  1852.   set_byte(dlp_buf+1, incategory);
  1853.   
  1854. #ifdef DLP_TRACE
  1855.   if (dlp_trace) {  
  1856.     fprintf(stderr, " Wrote: Handle: %d, Category: %d\n", fHandle, incategory);
  1857.   }
  1858. #endif
  1859.   
  1860.   result = dlp_exec(sd, 0x32, 0x20, dlp_buf, 2, dlp_buf, DLP_BUF_SIZE);
  1861.   
  1862.   Expect(10);
  1863.  
  1864. #ifdef DLP_TRACE
  1865.   if (dlp_trace) {  
  1866.     flags = get_byte(dlp_buf+8);
  1867.     fprintf(stderr, "  Read: ID: 0x%8.8lX, Index: %d, Category: %d\n        Flags:",
  1868.       (unsigned long)get_long(dlp_buf), get_short(dlp_buf+4), (int)get_byte(dlp_buf+9));
  1869.     if (flags & dlpRecAttrDeleted)
  1870.       fprintf(stderr, " Deleted");
  1871.     if (flags & dlpRecAttrDirty)
  1872.       fprintf(stderr, " Dirty");
  1873.     if (flags & dlpRecAttrBusy)
  1874.       fprintf(stderr, " Busy");
  1875.     if (flags & dlpRecAttrSecret)
  1876.       fprintf(stderr, " Secret");
  1877.     if (flags & dlpRecAttrArchived)
  1878.       fprintf(stderr, " Archive");
  1879.     if (!flags)
  1880.       fprintf(stderr, " None");
  1881.     fprintf(stderr, " (0x%2.2X), and %d bytes:\n", flags, result-10);
  1882.     dumpdata(dlp_buf+10, result-10);
  1883.   }
  1884. #endif
  1885.  
  1886.   if (id)
  1887.     *id = get_long(dlp_buf);
  1888.   if (index)
  1889.     *index = get_short(dlp_buf+4);
  1890.   if (size)
  1891.     *size = get_short(dlp_buf+6);
  1892.   if (attr)
  1893.     *attr = get_byte(dlp_buf+8);
  1894.   if (buffer)    
  1895.     memcpy(buffer, dlp_buf+10, result-10);
  1896.     
  1897.   return result-10;
  1898. }
  1899.  
  1900.  
  1901. int dlp_ReadAppPreference(int sd, unsigned long creator, int id, int backup,
  1902.                           int maxsize, void* buffer, int * size, int * version)
  1903. {
  1904.   int result;
  1905.  
  1906.   if (pi_version(sd) < 0x0101) {
  1907.     /* Emulate on PalmOS 1.0 */
  1908.     int db;
  1909.     int r;
  1910.  
  1911.     Trace(ReadAppPreferenceV1);
  1912.  
  1913. #ifdef DLP_TRACE
  1914.     if (dlp_trace) {  
  1915.       fprintf(stderr, "  Emulating with: Creator: '%s', Id: %d, Size: %d, Backup: %d\n", 
  1916.                       printlong(creator), id, buffer ? maxsize : 0, backup ? 0x80 : 0);
  1917.     }
  1918. #endif
  1919.     
  1920.     r = dlp_OpenDB(sd, 0, dlpOpenRead, "System Preferences", &db);
  1921.     if (r<0)
  1922.       return r;
  1923.     
  1924.     r = dlp_ReadResourceByType(sd, db, creator, id, buffer, NULL, size);
  1925.     
  1926.     
  1927.     if (r<0) {
  1928.       dlp_CloseDB(sd, db);
  1929.       return r;
  1930.     }
  1931.  
  1932.     if (size)
  1933.       *size -= 2;
  1934.     
  1935.     if (version)
  1936.       *version = get_short(buffer);
  1937.     
  1938.     if (r>2) {
  1939.       r-=2;
  1940.       memmove(buffer, ((char*)buffer)+2, r);
  1941.     } else {
  1942.       r = 0;
  1943.     }
  1944.     
  1945.     dlp_CloseDB(sd,db);
  1946.  
  1947.     return r;
  1948.   }
  1949.  
  1950.   Trace(ReadAppPreferenceV2);
  1951.  
  1952.   set_long(dlp_buf, creator);
  1953.   set_short(dlp_buf+4, id);
  1954.   set_short(dlp_buf+6, buffer ? maxsize : 0);
  1955.   set_byte(dlp_buf+8, backup ? 0x80 : 0);
  1956.   set_byte(dlp_buf+9, 0); /* Reserved */
  1957.   
  1958. #ifdef DLP_TRACE
  1959.   if (dlp_trace) {  
  1960.     fprintf(stderr, " Wrote: Creator: '%s', Id: %d, Size: %d, Backup: %d\n", 
  1961.                 printlong(creator), id, buffer ? maxsize : 0, backup ? 0x80 : 0);
  1962.   }
  1963. #endif
  1964.   
  1965.   result = dlp_exec(sd, 0x34, 0x20, dlp_buf, 10, dlp_buf, DLP_BUF_SIZE);
  1966.   
  1967.   Expect(6);
  1968.  
  1969. #ifdef DLP_TRACE
  1970.   if (dlp_trace) {  
  1971.     fprintf(stderr, " Read: Version: %d, Total size: %d, Read %d bytes:\n", 
  1972.                    get_short(dlp_buf), get_short(dlp_buf+2), get_short(dlp_buf+4));
  1973.     dumpdata(dlp_buf+6, get_short(dlp_buf+4));
  1974.   }
  1975. #endif
  1976.  
  1977.   if (version)
  1978.     *version = get_short(dlp_buf);
  1979.   if (size && !buffer)
  1980.     *size = get_short(dlp_buf+2); /* Total size */
  1981.   if (size && buffer)
  1982.     *size = get_short(dlp_buf+4); /* Size returned */
  1983.   if (buffer)
  1984.     memcpy(buffer, dlp_buf+6, get_short(dlp_buf+4));
  1985.     
  1986.   return get_short(dlp_buf+4);
  1987. }
  1988.  
  1989. int dlp_WriteAppPreference(int sd, unsigned long creator, int id, int backup,
  1990.                           int version, void * buffer, int size)
  1991. {
  1992.   int result;
  1993.  
  1994.   if (pi_version(sd) < 0x0101) {
  1995.     /* Emulate on PalmOS 1.0 */
  1996.     int db;
  1997.     int r;
  1998.  
  1999.     Trace(WriteAppPreferenceV1);
  2000.  
  2001. #ifdef DLP_TRACE
  2002.   if (dlp_trace) {  
  2003.     fprintf(stderr, " Wrote: Creator: '%s', Id: %d, Version: %d, Backup: %d, and %d bytes:\n", 
  2004.                     printlong(creator), id, version, backup ? 0x80 : 0, size);
  2005.     dumpdata(buffer, size);
  2006.   }
  2007. #endif
  2008.     
  2009.     r = dlp_OpenDB(sd, 0, dlpOpenWrite, "System Preferences", &db);
  2010.     if (r<0)
  2011.       return r;
  2012.       
  2013.     if (buffer && size) {
  2014.       memcpy(dlp_buf + 2, buffer, size);
  2015.       set_short(dlp_buf, version);
  2016.       r = dlp_WriteResource(sd, db, creator, id, dlp_buf, size);
  2017.     } else
  2018.       r = dlp_WriteResource(sd, db, creator, id, NULL, 0);
  2019.  
  2020.     dlp_CloseDB(sd, db);
  2021.     
  2022.     return r;
  2023.   }
  2024.  
  2025.   Trace(WriteAppPreferenceV2);
  2026.  
  2027.   set_long(dlp_buf, creator);
  2028.   set_short(dlp_buf+4, id);
  2029.   set_short(dlp_buf+6, version);
  2030.   set_short(dlp_buf+8, size);
  2031.   set_byte(dlp_buf+10, backup ? 0x80 : 0);
  2032.   set_byte(dlp_buf+11, 0); /* Reserved */
  2033.   
  2034.   if (size+12 > DLP_BUF_SIZE) {
  2035.     fprintf(stderr, "Data too large\n");
  2036.     return -131;
  2037.   }
  2038.   
  2039.   memcpy(dlp_buf+12, buffer, size);
  2040.   
  2041. #ifdef DLP_TRACE
  2042.   if (dlp_trace) {  
  2043.     fprintf(stderr, " Wrote: Creator: '%s', Id: %d, Version: %d, Backup: %d, and %d bytes:\n", 
  2044.                     printlong(creator), id, version, backup ? 0x80 : 0, size);
  2045.     dumpdata(buffer, size);
  2046.   }
  2047. #endif
  2048.   
  2049.   result = dlp_exec(sd, 0x35, 0x20, dlp_buf, 12+size, NULL, 0);
  2050.   
  2051.   Expect(0);
  2052.  
  2053.   return result;
  2054. }
  2055.  
  2056. int dlp_ReadNextModifiedRecInCategory(int sd, int fHandle, int incategory, void* buffer,
  2057.                           recordid_t* id, int* index, int* size, int* attr)
  2058. {
  2059.   int result;
  2060. #ifdef DLP_TRACE
  2061.   int flags;
  2062. #endif
  2063.  
  2064.   if (pi_version(sd) < 0x0101) {
  2065.     /* Emulate for PalmOS 1.0 */
  2066.     int cat;
  2067.     int r;
  2068.  
  2069.     Trace(ReadNextModifiedRecInCategoryV1);
  2070.  
  2071. #ifdef DLP_TRACE
  2072.   if (dlp_trace) {  
  2073.     fprintf(stderr, " Emulating with: Handle: %d, Category: %d\n", fHandle, incategory);
  2074.   }
  2075. #endif
  2076.     
  2077.     do {
  2078.       /* Fetch next modified record (in any category) */
  2079.       r = dlp_ReadNextModifiedRec(sd, fHandle, buffer, id, index, size, attr, &cat);
  2080.     
  2081.       /* If none found, reset modified pointer so that another search on a different
  2082.          (or the same!) category will start from the beginning */
  2083.       if (r < 0)
  2084.         dlp_ResetDBIndex(sd, fHandle);
  2085.           
  2086.       /* Loop until we fail to get a record or a record is found in the proper category */
  2087.     } while ((r >= 0) && (cat != incategory));
  2088.     
  2089.     return r;
  2090.   }
  2091.  
  2092.   Trace(ReadNextModifiedRecInCategoryV2);
  2093.  
  2094.   set_byte(dlp_buf, fHandle);
  2095.   set_byte(dlp_buf+1, incategory);
  2096.   
  2097. #ifdef DLP_TRACE
  2098.   if (dlp_trace) {  
  2099.     fprintf(stderr, " Wrote: Handle: %d, Category: %d\n", fHandle, incategory);
  2100.   }
  2101. #endif
  2102.   
  2103.   result = dlp_exec(sd, 0x33, 0x20, dlp_buf, 2, dlp_buf, DLP_BUF_SIZE);
  2104.   
  2105.   Expect(10);
  2106.  
  2107. #ifdef DLP_TRACE
  2108.   if (dlp_trace) {  
  2109.     flags = get_byte(dlp_buf+8);
  2110.     fprintf(stderr, "  Read: ID: 0x%8.8lX, Index: %d, Category: %d\n        Flags:",
  2111.       (unsigned long)get_long(dlp_buf), get_short(dlp_buf+4), (int)get_byte(dlp_buf+9));
  2112.     if (flags & dlpRecAttrDeleted)
  2113.       fprintf(stderr, " Deleted");
  2114.     if (flags & dlpRecAttrDirty)
  2115.       fprintf(stderr, " Dirty");
  2116.     if (flags & dlpRecAttrBusy)
  2117.       fprintf(stderr, " Busy");
  2118.     if (flags & dlpRecAttrSecret)
  2119.       fprintf(stderr, " Secret");
  2120.     if (flags & dlpRecAttrArchived)
  2121.       fprintf(stderr, " Archive");
  2122.     if (!flags)
  2123.       fprintf(stderr, " None");
  2124.     fprintf(stderr, " (0x%2.2X), and %d bytes:\n", flags, result-10);
  2125.     dumpdata(dlp_buf+10, result-10);
  2126.   }
  2127. #endif
  2128.  
  2129.   if (id)
  2130.     *id = get_long(dlp_buf);
  2131.   if (index)
  2132.     *index = get_short(dlp_buf+4);
  2133.   if (size)
  2134.     *size = get_short(dlp_buf+6);
  2135.   if (attr)
  2136.     *attr = get_byte(dlp_buf+8);
  2137.   if (buffer)    
  2138.     memcpy(buffer, dlp_buf+10, result-10);
  2139.     
  2140.   return result-10;
  2141. }
  2142.  
  2143.  
  2144. int dlp_ReadNextModifiedRec(int sd, int fHandle, void* buffer,
  2145.                           recordid_t* id, int* index, int* size, int* attr, int* category)
  2146. {
  2147.   unsigned char handle = fHandle;
  2148.   int result;
  2149. #ifdef DLP_TRACE
  2150.   int flags;
  2151. #endif
  2152.  
  2153.   Trace(ReadNextModifiedRec);
  2154.  
  2155. #ifdef DLP_TRACE
  2156.   if (dlp_trace) {  
  2157.     fprintf(stderr, " Wrote: Handle: %d\n", fHandle);
  2158.   }
  2159. #endif
  2160.   
  2161.   result = dlp_exec(sd, 0x1f, 0x20, &handle, 1, dlp_buf, DLP_BUF_SIZE);
  2162.   
  2163.   Expect(10);
  2164.  
  2165. #ifdef DLP_TRACE
  2166.   if (dlp_trace) {  
  2167.     flags = get_byte(dlp_buf+8);
  2168.     fprintf(stderr, "  Read: ID: 0x%8.8lX, Index: %d, Category: %d\n        Flags:",
  2169.       (unsigned long)get_long(dlp_buf), get_short(dlp_buf+4), (int)get_byte(dlp_buf+9));
  2170.     if (flags & dlpRecAttrDeleted)
  2171.       fprintf(stderr, " Deleted");
  2172.     if (flags & dlpRecAttrDirty)
  2173.       fprintf(stderr, " Dirty");
  2174.     if (flags & dlpRecAttrBusy)
  2175.       fprintf(stderr, " Busy");
  2176.     if (flags & dlpRecAttrSecret)
  2177.       fprintf(stderr, " Secret");
  2178.     if (flags & dlpRecAttrArchived)
  2179.       fprintf(stderr, " Archive");
  2180.     if (!flags)
  2181.       fprintf(stderr, " None");
  2182.     fprintf(stderr, " (0x%2.2X), and %d bytes:\n", flags, result-10);
  2183.     dumpdata(dlp_buf+10, result-10);
  2184.   }
  2185. #endif
  2186.  
  2187.   if (id)
  2188.     *id = get_long(dlp_buf);
  2189.   if (index)
  2190.     *index = get_short(dlp_buf+4);
  2191.   if (size)
  2192.     *size = get_short(dlp_buf+6);
  2193.   if (attr)
  2194.     *attr = get_byte(dlp_buf+8);
  2195.   if (category)
  2196.     *category = get_byte(dlp_buf+9);
  2197.   if (buffer)    
  2198.     memcpy(buffer, dlp_buf+10, result-10);
  2199.     
  2200.   return result-10;
  2201. }
  2202.  
  2203. int dlp_ReadRecordById(int sd, int fHandle, recordid_t id, void* buffer, 
  2204.                           int* index, int* size, int* attr, int* category)
  2205. {
  2206.   int result;
  2207. #ifdef DLP_TRACE
  2208.   int flags;
  2209. #endif
  2210.   
  2211.   set_byte(dlp_buf, fHandle);
  2212.   set_byte(dlp_buf+1, 0x00);
  2213.   set_long(dlp_buf+2, id);
  2214.   set_short(dlp_buf+6, 0); /* Offset into record */
  2215.   set_short(dlp_buf+8, buffer ? DLP_BUF_SIZE : 0); /* length to return */
  2216.  
  2217.   Trace(ReadRecordById);
  2218.  
  2219. #ifdef DLP_TRACE
  2220.   if (dlp_trace) {  
  2221.     fprintf(stderr, " Wrote: Handle: %d, Record ID: 0x%8.8lX\n", fHandle, id);
  2222.   }
  2223. #endif
  2224.   
  2225.   result = dlp_exec(sd, 0x20, 0x20, dlp_buf, 10, dlp_buf, DLP_BUF_SIZE);
  2226.  
  2227.   Expect(10);
  2228.  
  2229. #ifdef DLP_TRACE
  2230.   if (dlp_trace) {  
  2231.     flags = get_byte(dlp_buf+8);
  2232.     fprintf(stderr, "  Read: ID: 0x%8.8lX, Index: %d, Category: %d\n        Flags:",
  2233.       (unsigned long)get_long(dlp_buf), get_short(dlp_buf+4), (int)get_byte(dlp_buf+9));
  2234.     if (flags & dlpRecAttrDeleted)
  2235.       fprintf(stderr, " Deleted");
  2236.     if (flags & dlpRecAttrDirty)
  2237.       fprintf(stderr, " Dirty");
  2238.     if (flags & dlpRecAttrBusy)
  2239.       fprintf(stderr, " Busy");
  2240.     if (flags & dlpRecAttrSecret)
  2241.       fprintf(stderr, " Secret");
  2242.     if (flags & dlpRecAttrArchived)
  2243.       fprintf(stderr, " Archive");
  2244.     if (!flags)
  2245.       fprintf(stderr, " None");
  2246.     fprintf(stderr, " (0x%2.2X), and %d bytes:\n", flags, result-10);
  2247.     dumpdata(dlp_buf+10, result-10);
  2248.   }
  2249. #endif
  2250.   
  2251.   /*id = get_long(dlp_buf);*/
  2252.   if (index)
  2253.     *index = get_short(dlp_buf+4);
  2254.   if (size)
  2255.     *size = get_short(dlp_buf+6);
  2256.   if (attr)
  2257.     *attr = get_byte(dlp_buf+8);
  2258.   if (category)
  2259.     *category = get_byte(dlp_buf+9);
  2260.   if (buffer)
  2261.     memcpy(buffer, dlp_buf+10, result-10);
  2262.  
  2263.   return result-10;
  2264. }
  2265.  
  2266. int dlp_ReadRecordByIndex(int sd, int fHandle, int index, void* buffer,
  2267.                           recordid_t* id, int* size, int* attr, int* category)
  2268. {
  2269.   int result;
  2270. #ifdef DLP_TRACE
  2271.   int flags;
  2272. #endif
  2273.   
  2274.   set_byte(dlp_buf, fHandle);
  2275.   set_byte(dlp_buf+1, 0x00);
  2276.   set_short(dlp_buf+2, index);
  2277.   set_short(dlp_buf+4, 0); /* Offset into record */
  2278.   set_short(dlp_buf+6, buffer ? DLP_BUF_SIZE : 0); /* length to return */
  2279.  
  2280.   Trace(ReadRecordByIndex);
  2281.  
  2282. #ifdef DLP_TRACE
  2283.   if (dlp_trace) {  
  2284.     fprintf(stderr, " Wrote: Handle: %d, Index: %d\n", fHandle, index);
  2285.   }
  2286. #endif  
  2287.  
  2288.   result = dlp_exec(sd, 0x20, 0x21, dlp_buf, 8, dlp_buf, DLP_BUF_SIZE);
  2289.   
  2290.   Expect(10);
  2291.   
  2292. #ifdef DLP_TRACE
  2293.   if (dlp_trace) {  
  2294.     flags = get_byte(dlp_buf+8);
  2295.     fprintf(stderr, "  Read: ID: 0x%8.8lX, Index: %d, Category: %d\n        Flags:",
  2296.       (unsigned long)get_long(dlp_buf), get_short(dlp_buf+4), (int)get_byte(dlp_buf+9));
  2297.     if (flags & dlpRecAttrDeleted)
  2298.       fprintf(stderr, " Deleted");
  2299.     if (flags & dlpRecAttrDirty)
  2300.       fprintf(stderr, " Dirty");
  2301.     if (flags & dlpRecAttrBusy)
  2302.       fprintf(stderr, " Busy");
  2303.     if (flags & dlpRecAttrSecret)
  2304.       fprintf(stderr, " Secret");
  2305.     if (flags & dlpRecAttrArchived)
  2306.       fprintf(stderr, " Archive");
  2307.     if (!flags)
  2308.       fprintf(stderr, " None");
  2309.     fprintf(stderr, " (0x%2.2X), and %d bytes:\n", flags, result-10);
  2310.     dumpdata(dlp_buf+10, result-10);
  2311.   }
  2312. #endif
  2313.  
  2314.   if (id)
  2315.     *id = get_long(dlp_buf);
  2316.   /*get_short(dlp_buf+4) == index*/
  2317.   if (size)
  2318.     *size = get_short(dlp_buf+6);
  2319.   if (attr)
  2320.     *attr = get_byte(dlp_buf+8);
  2321.   if (category)
  2322.     *category = get_byte(dlp_buf+9);
  2323.   if (buffer)
  2324.     memcpy(buffer, dlp_buf+10, result-10);
  2325.  
  2326.   return result-10;
  2327. }
  2328.